Contrôle MQTT planifié

astuce

Le contrôle MQTT programmé est destiné aux messages planifiés à l'avance. Pour un contrôle en direct, consultez plutôt Contrôle MQTT en direct.

Ce guide vous aidera à configurer MQTT sur votre SmartgridOne Controller pour contrôler et surveiller à distance les installations de batteries et de panneaux solaires.

Ce dont vous avez besoin

SmartgridOne Controller avec connectivité Internet.
Identifiants MQTT : Cela peut être demandé en envoyant un e-mail à support@eniris.be.
Environnement de développement Python (ou tout autre client MQTT). Ce guide utilise un exemple de base écrit en Python pour vous aider à démarrer avec MQTT et l'envoi de commandes. Nous recommandons d'utiliser Python pour sa facilité d'utilisation, mais tout autre client MQTT est pris en charge.

Informations supplémentaires

MQTT est un protocole de communication rapide sur Internet. Il s'agit d'un système de messagerie de publication/abonnement, qui permet une connexion directe entre votre machine et le SmartgridOne Controller. Vos actifs sont classés en groupes de panneaux solaires, de batteries, de véhicules électriques et de climatisation. Pour le moment, cette intégration permet un contrôle par groupe, et non par appareil.

Configuration initiale (Point de départ pour les nouveaux utilisateurs)

J'ai un SmartgridOne Controller que j'aimerais configurer pour le contrôle à distance MQTT.

1. Vérifiez votre réseau

Assurez-vous que votre réseau permet le trafic réseau MQTT sur le port 1883. Vous pouvez le faire en utilisant la commande :

nc -zv mqtt.eniris.be 1883

Lorsque cette commande n'est pas disponible, vous pouvez alternativement télécharger et exécuter ce code python.

En cas de doute, consultez votre ingénieur réseau ou utilisez temporairement le point d'accès 4G/5G de votre téléphone lorsque des erreurs de connexion se produisent.

remarque

Lorsque le port 1883 n'est pas accessible depuis votre réseau, nous proposons un port de secours au port 80. Cela peut être configuré dans votre client MQTT à une étape ultérieure de ce manuel.

2. Ajoutez vos appareils

Connectez-vous à l'interface de mise en service et assurez-vous que les appareils sont ajoutés au SmartgridOne Controller.

3. Ajoutez le signal externe MQTT

4. Activez le signal à distance MQTT

Sélectionnez tous les appareils que vous souhaitez inclure dans le contrôle à distance MQTT.

5. Le signal à distance est ajouté

L'interface de contrôle à distance MQTT a maintenant été activée sur le SmartgridOne Controller.

Nous sommes maintenant prêts à envoyer quelques commandes de base en utilisant un exemple simple. La colonne Statut vous indique si une commande est active.

Script de démonstration Python

Un bon point de départ serait de tester votre intégration nouvellement configurée avec un exemple simple.

Ce code de test effectue une tâche simple en envoyant en continu le programme suivant :

Batterie : Charge à 5 kW pendant 15 minutes dans 10 minutes
Solaire : Régler la puissance à 0 kW pendant une heure dans 30 minutes

Le SmartgridOne Controller répond avec un message d'accusé de réception contenant l'identifiant unique du programme, ou un message d'erreur.

Nous récupérons ensuite le programme suivant pour les deux types d'appareils, confirmant que la commande a été effectuée avec succès.

Veuillez télécharger le fichier ci-dessous dans votre IDE Python préféré. Remplissez votre numéro de série et vos identifiants MQTT et exécutez le script :

Lorsque cela est réussi, vous pouvez continuer à envoyer d'autres types de messages. Tous les messages sont décrits ci-dessous.

Documentation MQTT pour l'envoi de commandes

Cette section détaille le format de messagerie MQTT et les exigences de charge utile pour configurer le contrôle programmé des appareils au sein du réseau du SmartgridOne Controller.

Sujets MQTT

Sujet d'abonnement : standard1/rp_one_s/remoteScheduleMetrics/<controller SN>
Sujet de retour : standard1/outbound/remoteScheduleMetrics/feedback/<controller SN>

Où <controller SN> doit être remplacé par le numéro de série réel du SmartgridOne Controller que vous souhaitez contrôler.

Types de messages MQTT

1. Définir le programme (`set_schedule`)

Crée un nouveau programme pour un type d'appareil.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "set_schedule",
    "fields": {
        "device_type": "<Device Type>",
        "node_id": "<Node ID>" (Facultatif),
        "start_time": <Unix Timestamp>,
        "end_time": <Unix Timestamp>,
        "policy": "<Policy>",
        "power_setpoint_w": <Setpoint in watts>,
        "site_import": <Site Import in Watts>,
        "site_export": <Site Export in Watts>,
        "remove_overlap": <True/False> (Facultatif) (par défaut=False),
        "tag": <Tag String> (Facultatif) (par défaut=None),
    }
}

Réponse (Succès) :

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "set_schedule_ack",
        "state": {
            "schedule_id": <Schedule ID>,
            "deleted_ids": <Schedulde IDs supprimés si remove_overlap=True>
            "tag": <Tag String> (par défaut=None),
        },
        "responseCode": 0
    }
}

2. Définir les programmes (`set_schedules`)

Crée plusieurs nouveaux programmes.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "set_schedules",
    "fields": 
        "0": '{
            "device_type": "<Device Type>",
            "node_id": "<Node ID>" (Facultatif),
            "start_time": <Unix Timestamp>,
            "end_time": <Unix Timestamp>,
            "policy": "<Policy>",
            "power_setpoint_w": <Setpoint in watts>,
            "site_import": <Site Import in Watts>,
            "site_export": <Site Export in Watts>,
            "remove_overlap": <True/False> (Facultatif) (par défaut=False),
        }', 
        "1": '{
            "device_type": "<Device Type>",
            "node_id": "<Node ID>" (Facultatif),
            "start_time": <Unix Timestamp>,
            "end_time": <Unix Timestamp>,
            "policy": "<Policy>",
            "power_setpoint_w": <Setpoint in watts>,
            "site_import": <Site Import in Watts>,
            "site_export": <Site Export in Watts>,
            "remove_overlap": <True/False> (Facultatif) (par défaut=False),
        }', 
        ...
}

Réponse (Succès) :

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "set_schedules_ack",
        "state": {
            "schedule_ids": <Schedule IDs>,
            "deleted_ids": <Schedulde IDs supprimés si remove_overlap=True>
        },
        "responseCode": 0
    }
}

3. Obtenir le programme (`get_schedule`)

Récupère un programme spécifique par ID.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_schedule",
    "fields": {
        "id": <Schedule ID>
    }
}

Réponse :

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_schedule_ack",
        "state": <Schedule>,
        "responseCode": 0
    }
}

4. Obtenir le programme actif (`get_active_schedule`)

Récupère le programme actuellement actif pour un type de dispositif.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_active_schedule",
    "fields": {
        "device_type": "<Device Type>",
        "node_id": "<Node ID>" (Optionnel),
    }
}

Réponse (Succès):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_active_schedule_ack",
        "state": <Schedule>,
        "responseCode": 0
    }
}

5. Obtenir le prochain programme (`get_next_schedule`)

Récupère le prochain programme à venir pour un type de dispositif.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_next_schedule", 
    "fields": {
        "device_type": "<Device Type>",
        "node_id": "<Node ID>" (Optionnel),
    }
}

Réponse (Succès):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_next_schedule_ack",
        "state": <Schedule>,
        "responseCode": 0
    }
}

6. Obtenir les programmes (`get_schedules`)

Récupère tous les programmes pour une date spécifique.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_schedules",
    "fields": {
        "date": "<Date String of Format dd/mm/yyyy>"
    }
}

Réponse (Succès):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_schedules_ack",
        "state": {
            "schedules": [<Schedule>, ...]
        },
        "responseCode": 0
    }
}

7. Obtenir les programmes futurs (`get_future_schedules`)

Récupère tous les programmes futurs.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_future_schedules",
    "fields": {}
}

Réponse (Succès):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_future_schedules_ack",
        "state": {
            "schedules": [<Schedule>, ...]
        },
        "responseCode": 0
    }
}

8. Supprimer un programme (`remove_schedule`)

Supprime un programme spécifique par ID.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "remove_schedule",
    "fields": {
        "id": <Schedule ID>
    }
}

Réponse (Succès):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "remove_schedule_ack",
        "state": "Programme <Schedule ID> supprimé avec succès",
        "responseCode": 0
    }
}

9. Obtenir des retours de site (`get_feedback`)

Récupère des retours détaillés sur l'état du système.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_feedback",
    "fields": {
        "device": <Device (node) level>
    }
}

Réponse (Succès):

Structure de charge utile de retour

10. Topologie du site (`get_toplogy`)

Obtient la topologie du site.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_topology",
    "fields": {}
}

Réponse (Succès):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_topology_ack",
        "state": {
            "nodeId": <nodeId>,
            "nodeType": <nodeType>,
            "nomCurrent": <nominalCurrent>,
            "children": [{<ChildObject>}]
            },
        "responseCode": 0
    }
}

Format de réponse standard des programmes

{
    "id": <Schedule ID>,
    "device_type": "<Device Type>",
    "node_id": "<Node ID>" (Optionnel),
    "start_time": <Unix Timestamp>,
    "end_time": <Unix Timestamp>,
    "policy": "<Schedule Policy>",
    "power_setpoint_w": <Setpoint in watts>,
    "created_at": <Unix Timestamp>
}

Types de composants et politiques

Pour plus de détails sur les composants disponibles et les politiques pouvant être planifiées, consultez la section Composants et Politiques MQTT dans la documentation du contrôle MQTT en direct.

Des programmes spécifiques à un dispositif peuvent être envoyés en utilisant le champ optionnel node_id, se référant à l'ID du nœud du dispositif contrôlable.

Gestion des erreurs

Tous les messages peuvent renvoyer une réponse d'erreur avec responseCode: 1 lorsqu'une erreur se produit :

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "<Message Type>_ack",
        "error": <Error Body>,
        "responseCode": 1
    }
}

Lorsqu'une erreur non liée se produit, le type de message sera (general_error).

Les erreurs courantes incluent :

Chevauchement de programme avec des programmes existants
Plage horaire invalide
Type de dispositif non trouvé
ID de programme non trouvé
Politique invalide pour le type de dispositif

Règles de gestion des programmes

Règles de chevauchement
- Les programmes ne peuvent pas se chevaucher pour le même type de dispositif
- Les programmes ne peuvent pas se chevaucher pour le même dispositif
- Les programmes pour le même dispositif et type de dispositif ne peuvent pas se chevaucher
- Les programmes existants en chevauchement seront supprimés si la variable remove_overlap est définie sur True lors de la création d'un nouveau programme.
Chaque programme doit avoir :
- Un type de dispositif valide
- Un temps de début (horodatage Unix)
- Un temps de fin (horodatage Unix)
- Une politique (correspondant aux politiques disponibles pour le type de dispositif)
- Un point de consigne de puissance (pour les politiques qui l'exigent)
Le temps de début doit être antérieur au temps de fin
Si le temps de début est dans le passé, il est automatiquement changé pour commencer maintenant
Les programmes ne peuvent être supprimés que s'ils n'ont pas encore commencé. Les programmes actifs ne peuvent pas être supprimés.
Les programmes peuvent être définis pour différents types de dispositifs de manière indépendante
Le système applique automatiquement la politique appropriée lorsque qu'un programme devient actif

Ce dont vous avez besoin​

Informations supplémentaires​

Configuration initiale (Point de départ pour les nouveaux utilisateurs)​

1. Vérifiez votre réseau​

2. Ajoutez vos appareils​

3. Ajoutez le signal externe MQTT​

4. Activez le signal à distance MQTT​

5. Le signal à distance est ajouté​

Script de démonstration Python​

Documentation MQTT pour l'envoi de commandes​

Sujets MQTT​

Types de messages MQTT​

1. Définir le programme (set_schedule)​

2. Définir les programmes (set_schedules)​

3. Obtenir le programme (get_schedule)​

4. Obtenir le programme actif (get_active_schedule)​

5. Obtenir le prochain programme (get_next_schedule)​

6. Obtenir les programmes (get_schedules)​

7. Obtenir les programmes futurs (get_future_schedules)​

8. Supprimer un programme (remove_schedule)​

9. Obtenir des retours de site (get_feedback)​

10. Topologie du site (get_toplogy)​

Format de réponse standard des programmes​

Types de composants et politiques​

Gestion des erreurs​

Règles de gestion des programmes​

Ce dont vous avez besoin

Informations supplémentaires

Configuration initiale (Point de départ pour les nouveaux utilisateurs)

1. Vérifiez votre réseau

2. Ajoutez vos appareils

3. Ajoutez le signal externe MQTT

4. Activez le signal à distance MQTT

5. Le signal à distance est ajouté

Script de démonstration Python

Documentation MQTT pour l'envoi de commandes

Sujets MQTT

Types de messages MQTT

1. Définir le programme (`set_schedule`)

2. Définir les programmes (`set_schedules`)

3. Obtenir le programme (`get_schedule`)

4. Obtenir le programme actif (`get_active_schedule`)

5. Obtenir le prochain programme (`get_next_schedule`)

6. Obtenir les programmes (`get_schedules`)

7. Obtenir les programmes futurs (`get_future_schedules`)

8. Supprimer un programme (`remove_schedule`)

9. Obtenir des retours de site (`get_feedback`)

10. Topologie du site (`get_toplogy`)

Format de réponse standard des programmes

Types de composants et politiques

Gestion des erreurs

Règles de gestion des programmes